Usenet 1993 July/InfoMagic USENET CD-ROM July 1993.ISO/sources/sun/volume1/ethertools-3.x/part02

Text File | 1989-06-21 | 52.5 KB | 2,176 lines

Path: uunet!lll-winken!csd4.milw.wisc.edu!bionet!apple!rutgers!aramis.rutgers.edu!dartagnan.rutgers.edu!mcgrew
From: [e-mail] (Charles Mcgrew)
Newsgroups: comp.sources.sun
Subject: v01i037:  Ethernet tools for SunOS 3.X, Part02/02
Message-ID: <[e-mail]>
Date: 21 Jun 89 17:54:15 GMT
Organization: Rutgers Univ., New Brunswick, N.J.
Lines: 2165
Approved: [e-mail]

Submitted-by: [e-mail]
Posting-number: Volume 1, Issue 37
Archive-name: ethertools-3.X/part02

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#        "End of archive 2 (of 2)."
# Contents:  ctp.c if_ctp.c nit.c packet.h rlog.c
# Wrapped by budd@buita on Sat Aug 13 01:14:42 1988
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f ctp.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"ctp.c\"
else
echo shar: Extracting \"ctp.c\" \(10642 characters\)
sed "s/^X//" >ctp.c <<'END_OF_ctp.c'
X/*
X * Copyright (c) 1988 Philip L. Budne and The Trustees of Boston University
X * All Rights Reserved
X *
X * Permission is granted to any individual or institution to use, copy,
X * or redistribute this software so long as it is not sold for profit,
X * provided that this notice and the original copyright notices are
X * retained.  Boston University makes no representations about the
X * suitability of this software for any purpose.  It is provided "as is"
X * without express or implied warranty.
X */
X/*
X *    CTP -- Ethernet v2 Configuration Test Protocol User Process
X *    Philip L. Budne @ Boston University / Distributed Systems
X *
X */
X
X# include <sys/types.h>
X# include <sys/time.h>
X# include <net/nit.h>
X# include <signal.h>
X# include <stdio.h>
X# include "ctp.h"
X
X/*
X * SIGH.  Move sender to child?
X * print loss.
X * print variance.
X */
X
X# define SHM
X
Xtypedef u_char ea_t[6];            /* ethernet address type */
X
X# ifdef SHM
X# include <sys/ipc.h>
X# include <sys/shm.h>
X
Xint shmid;
Xchar *shmaddr, *shmat();
X
X# define NCOUNTS 8
X# define NCOUNT (1<<(NCOUNTS))
Xstruct stats {
X    int total;                /* total count */
X    int highseq;            /* highest seq seen */
X    int outofseq;            /* number recvd out of sequence */
X    int min, max;            /* min and max times */
X    int sum, sumsq;            /* sum of times, sum of squares */
X    int counts[ NCOUNT ];
X    /* array of addrs? */
X};
X
Xint lastseq = 0;
Xint nsent = 0;
X# endif /* SHM defined */
X
Xint seq = 0;
X
Xstruct packet {                /* CTP packet layout */
X    ea_t    p_dst;            /* Ethernet dest */
X    ea_t    p_src;            /* Ethernet src */
X    u_short p_type;            /* Ethernet type (802 length) */
X    u_short p_skip;            /* CTP skip */
X    u_char  p_data[ 2048 ];        /* ... */
X};
X
Xstruct ctp_forward {            /* forward subpacket */
X    u_short cf_function;        /* CTP_FWD */
X    ea_t    cf_addr;
X};
X
Xstruct ctp_reply {            /* reply subpacket */
X    u_short cr_function;        /* CTP_REP */
X    /* The following is data that we use for own purposes */
X    u_short cr_pid;            /* pid of sender -- not swapped */
X    u_short cr_seq;            /* sequence number -- not swapped */
X    struct timeval cr_sendt;        /* time packet was sent */
X    /* more data here.. */
X};
X
Xea_t localaddr;                /* our ethernet address */
X
X# define MAXPATH 200            /* !! (more than can fit in a packet) */
Xea_t path[ MAXPATH];            /* path list */
Xint pathcount = 0;            /* length of path list */
X
X# define MINPACK 60            /* minimum ether packet */
X# define MAXPACK 1516            /* maximum ether packet */
X
Xint count = -1;                /* number of packets to send */
Xchar ifbuf[ 100 ];
Xchar *interface = ifbuf;        /* interface to use */
Xint verbose = 0;            /* extra output */
Xint noreturn = 0;            /* don't force final forward back */
Xint debug = 0;                /* don't fork */
Xint packlen = MINPACK;            /* default total packet length */
Xint slptim = 1000;            /* sleep time in ms */
X
Xint pid;                /* parent pid */
Xint child;                /* child pid */
X
Xmain(argc, argv)
X    int argc;
X    char *argv[];
X{
X    extern char *optarg;
X    extern int optind, opterr;
X    int s, c, errs;
X    void nit_input();            /* forward */
X
X    errs = 0;
X    while( (c = getopt( argc, argv, "c:di:l:ns:v" )) != EOF ) {
X    switch( c ) {
X    case 'c':
X        count = atoi( optarg );
X        break;
X    case 'd':
X        debug ^= 1;
X        break;
X    case 'i':
X        interface = optarg;
X        break;
X    case 'l':
X        packlen = atoi( optarg );
X        if( packlen < MINPACK )
X        packlen = MINPACK;
X        else if( packlen > MAXPACK )
X        packlen = MAXPACK;
X        break;
X    case 'n':
X        noreturn ^= 1;
X        break;
X    case 's':
X        slptim = atoi( optarg );
X        break;
X    case 'v':
X        verbose ^= 1;
X        break;
X    default:
X        errs++;
X    } /* switch */
X    } /* while getopt */
X    if( errs > 0 ) {
X    fprintf( stderr, "Usage: %s [-c count] [-d] [-i ifn] ", argv[0] );
X    fprintf( stderr, "[-l len] [-n] [-s sleep] [-v] [addr ...]\n");
X    fprintf( stderr, "addr <- ether-addr | ipaddr | iphost | ");
X    fprintf( stderr, "etherhost | 'BCAST' | 'MCAST'\n" );
X    exit( 1 );
X    }
X
X    pid = getpid();            /* get parent pid */
X    s = nit_open( interface, ETHERTYPE_CTP, localaddr, 0 );
X    printf("%s address ", interface );
X    petaddr( localaddr );
X    puts( "" );
X
X    pathcount = 0;
X    while( optind < argc && pathcount < MAXPATH && argv[optind] != NULL ) {
X    if( strcmp( argv[optind], "MCAST" ) == 0 ) {    /* CTP mcast addr */
X        register u_char *ea;
X        ea = path[pathcount];
X        *ea++ = 0XCF;
X        *ea++ = 0x00;
X        *ea++ = 0x00;
X        *ea++ = 0x00;
X        *ea++ = 0x00;
X        *ea   = 0x00;
X    }
X    else if( !htoea( argv[ optind ], path[pathcount] ) ) {
X        fprintf( stderr, "%s: unknown host %s\n",
X            argv[0], argv[optind] );
X        exit( 1 );
X    } /* bad host */
X    pathcount++;
X    optind++;
X    } /* while hosts */
X
X    if( pathcount == 0 ) {        /* if no hosts */
X    bcopy( bcast, path[0], sizeof( ea_t ) ); /* broadcast */
X    pathcount++;            /* fake count */
X    } /* empty path */
X
X    if( debug )
X    ctp_send( s );            /* just send */
X    else {
X# ifdef SHM
X    void gotint(), die(), poop();
X    struct stats *sp;
X
X    signal( SIGINT, gotint );
X    signal( SIGHUP, die );
X    signal( SIGKILL, die );
X
X    shmid = shmget( IPC_PRIVATE, sizeof( struct stats ), 0600 );
X    shmaddr = shmat( shmid, 0, 0 );
X    sp = (struct stats *)shmaddr;
X    bzero( sp, sizeof( struct stats ) );
X    sp->min = 100000;
X    sp->max = -1;
X# endif /* SHM defined */
X
X    switch( (child = fork()) ) {
X    case -1:
X        perror( "fork" );
X        exit( 1 );
X        /* NOTREACHED */
X
X    case 0:
X# ifdef SHM
X        signal( SIGINT,  poop );
X        signal( SIGHUP,  poop );
X        signal( SIGKILL, poop );
X# endif /* SHM defined */
X        nit_loop( s, nit_input );    /* input in child */
X        /* NOTREACHED */
X
X    default:
X        ctp_send(s);        /* output in parent */
X        /* NOTREACHED */
X    } /* switch */
X    }
X} /* main */
X
X# ifdef SHM
Xvoid
Xdie() {
X    (void) shmdt( shmaddr );
X    (void) shmctl( shmid, IPC_RMID, 0 );
X    exit( 0 );
X}
X
Xvoid
Xpoop() {
X    exit( 1 );
X}
X
Xvoid
Xstats() {
X    register struct stats *sp;
X
X    sp = (struct stats *) shmaddr;
X    printf("----CTP statistics----\n");
X    printf("%d Packet%s Sent, %d Recieved\n",
X       nsent, (nsent == 1 ? "" : "s"), sp->total );
X    if( sp->total > 0 )
X    printf("round-trip (ms)  min/avg/max = %d/%d/%d var=%d\n",
X           sp->min, sp->sum / sp->total, sp->max,
X           0 );
X} /* stats */
X
Xvoid
Xgotint() {
X    puts("");
X    stats();
X    die();
X}
X
X# endif /* SHM defined */
X
X/****************************************************************/
X
Xvoid
Xnit_input( s, nh )
X    int s;
X    struct nit_hdr *nh;
X{
X    int l;
X    u_char *p2;
X    int len, l2, ms;
X    short f, skip, seq;
X    struct packet *pp;
X    struct ctp_reply *cr;
X# ifdef SHM
X    register struct stats *sp;
X    sp = (struct stats *) shmaddr;
X# endif /* SHM defined */
X
X    l = nh->nh_datalen;
X    pp = (struct packet *) (((u_char *)nh) + sizeof( struct nit_hdr ));
X
X    skip = pp->p_skip;            /* fetch skip */
X    skip = SSWAP( skip );        /* swap it */
X
X    if( skip & 1 )
X    return;                /* skip must not be odd */
X
X    p2 = (u_char *) pp->p_data + skip;
X    len = l - 14 - skip - 2;        /* length of data */
X
X    if( len < 2 )            /* no room for function */
X    return;
X
X    cr = (struct ctp_reply *) p2;    /* get reply struct */
X    f = CTP_SHORT( p2 );        /* get function */
X    p2 += 2;                /* advance past function */
X    len -= 2;                /* account for function length */
X    switch( f ) {
X    case CTP_REP:            /* reply */
X    break;
X
X    case CTP_FWD:
X    return;                /* we are a client. */
X    break;
X
X    default:
X/*    printf(" fncn %d. data: ", f );    /* !! */
X    return;
X    }
X
X    if( cr->cr_pid != pid )        /* check for parent pid */
X    return;
X
X    p2 += 2;                /* advance past pid */
X    len -= 4;                /* pid, seq */
X
X    printf("%d bytes from ", l );
X    petaddr( pp->p_src );
X    seq = CTP_SHORT( p2 );
X    ms = delta( &nh->nh_timestamp, &cr->cr_sendt );
X    printf(": seq %2d. time=%dms\n", seq, ms );
X
X# ifdef SHM
X    sp->total++;
X    if( seq != lastseq && seq != lastseq+1 )
X    sp->outofseq++;
X    lastseq = seq;
X    if( ms > sp->max )
X    sp->max = ms;
X    if( ms < sp->min )
X    sp->min = ms;
X    if( seq > sp->highseq )
X    sp->highseq = seq;
X    sp->sum += ms;
X    sp->sumsq = ms * ms;
X    sp->counts[ seq & (NCOUNT-1) ]++;
X# endif /* SHM defined */
X} /* nit_input */
X
Xdelta( a, b )
X    struct timeval *a, *b;
X{
X    int usec, sec;
X    usec = a->tv_usec - b->tv_usec;
X    sec  = a->tv_sec  - b->tv_sec;
X
X    if( usec < 0 )   {
X    sec--;
X    usec += 1000000;
X    }
X    usec += 999;            /* round to ms */
X    sec = sec * 1000 + usec / 1000;    /* get ms */
X    if( sec < 0 ) {
X    printf("a: %d %d b: %d %d\n",
X           a->tv_sec, a->tv_usec,
X           b->tv_sec, b->tv_usec );
X    return( 0 );
X    } /* sec < 0 */
X    return( sec );
X} /* delta */
X
X/****************************************************************/
X
Xctp_send( s )
X    int s;
X{
X    struct timezone tz;
X    struct ctp_forward *cf;
X    struct ctp_reply *cr, *ocr;
X    struct packet p;
X    u_char *cp;
X    int i, c;
X
X    printf("to ");
X    for( i = 0; i < pathcount; i++ ) {
X    if( i > 0 )
X        printf(", ");
X    petaddr( path[i] );
X    }
X
X    /* fill in ether packet header */
X    bcopy( path[ 0 ], p.p_dst, sizeof( p.p_dst ) ); /* fill in initial dest */
X    p.p_type = ETHERTYPE_CTP;        /* fill in type */
X    p.p_skip = SSWAP( 0 );        /* fill in initial CTP skip */
X
X    cf = (struct ctp_forward *) p.p_data; /* get data pointer */
X    for( i = 1; i < pathcount; i++ ) {
X    cf->cf_function = SSWAP( CTP_FWD );
X    bcopy( path[i], cf->cf_addr, sizeof( ea_t ) );
X    cf++;                /* advance pointer */
X    }
X
X    /* ensure packet gets back -- append forward to ourselves */
X    if( !noreturn &&
X       bcmp( path[pathcount-1], localaddr, sizeof( localaddr ) ) != 0 ) {
X    cf->cf_function = SSWAP( CTP_FWD );
X    bcopy( localaddr, cf->cf_addr, sizeof( localaddr ) );
X    cf++;
X    }
X
X    /* create reply data */
X    cr = (struct ctp_reply *) cf;
X    cr->cr_function = SSWAP( CTP_REP );
X    cr->cr_pid = pid;            /* pid of parent */
X    ocr = cr;                /* save pointer for timestamp */
X    cr++;                /* advance past reply */
X
X    cp = (u_char *) cr;            /* get pointer to reply data */
X    i = cp - (u_char *)&p;        /* get length of packet so far */
X
X    if( i > packlen )
X    if( i > MAXPACK ) {
X        fprintf( stderr, "Packet too large without data (%d)\n", i );
X        exit( 1 );
X    }
X    else
X        packlen = i;
X
X    printf(": %d data bytes (%d total)\n", packlen - i, packlen );
X    fflush( stdout );
X
X    while( i < packlen )
X    *cp++ = i++ & 0xff;
X
X    slptim *= 1000;            /* convert to usec */
X    while( count != 0 ) {
X    if( count > 0 )
X        count--;
X    ocr->cr_seq = SSWAP( seq );
X    seq++;                /* update sequence */
X    gettimeofday( &ocr->cr_sendt, &tz );
X
X    if( nit_output( s, &p, packlen ) < 0 )
X        perror( "write" );
X    else
X        nsent++;
X    usleep( slptim );
X    }
X    kill( child, SIGINT );
X    stats();
X    die();
X} /* ctp_send */
END_OF_ctp.c
if test 10642 -ne `wc -c <ctp.c`; then
    echo shar: \"ctp.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f if_ctp.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"if_ctp.c\"
else
echo shar: Extracting \"if_ctp.c\" \(5585 characters\)
sed "s/^X//" >if_ctp.c <<'END_OF_if_ctp.c'
X/*
X * Copyright (c) 1988 Philip L. Budne and The Trustees of Boston University
X * All Rights Reserved
X *
X * Permission is granted to any individual or institution to use, copy,
X * or redistribute this software so long as it is not sold for profit,
X * provided that this notice and the original copyright notices are
X * retained.  Boston University makes no representations about the
X * suitability of this software for any purpose.  It is provided "as is"
X * without express or implied warranty.
X */
X/*
X * if_ctp.c -- Ethernet Version 2 Configuation Test Protocol (CTP)
X *
X * DEC DEUNA does this at the controller level??
X */
X
X
X/*
X * Called from do_protocol in sunif/if_subr.c;
X *
X *#endif INET
X>*#ifdef ETHERPUP_CTPTYPE:
X>*    case ETHERPUP_CTPTYPE:
X>*        ctp_input( header, m, &ap->ac_if );
X>*        break;
X>*#endif ETHERPUP_CTPTYPE:
X *    default:
X */
X
X/*
X * add to /sys/conf/files;
X * sunif/if_ctp.c        optional ether
X */
X
X/* add to netinet/if_ether.h;
X/* #define ETHERTYPE_CTP    0x9000        /* Config. Test Protocol */
X/* ... */
X/* #define ETHERPUP_CTPTYPE    0x9000        /* Config. Test Protocol */
X
X
X# include "ether.h"
X
X# if NETHER > 0
X# include "../h/param.h"
X# include "../h/systm.h"
X# include "../h/mbuf.h"
X# include "../h/socket.h"
X# include "../h/time.h"
X# include "../h/kernel.h"
X# include "../h/errno.h"
X# include "../h/ioctl.h"
X
X# include "../net/if.h"
X# include "../netinet/in.h"        /* for if_ether */
X# include "../netinet/if_ether.h"    /* for ether_header */
X
X# define DEBUG
X
X# define CTP_REP 1
X# define CTP_FWD 2
X
X# if defined(vax) || defined(ns32000)    /* machine is a byteswapper? */
X# define SWAP(s) (s)            /* CTP wants them swapped!! */
X# else /* not defined(vax) || defined(ns32000) */
X# define SWAP(s) ((((s)>>8) & 0xff) | (((s)<<8) & 0xff00))
X# endif /* not defined(vax) || defined(ns32000) */
X
X# ifndef ETHERTYPE_CTP
X# define ETHERTYPE_CTP 0x9000        /* 90-00 */
X# endif /* ETHERTYPE_CTP not defined */
X
X# define SP(s) ((u_short *)s)
X# define SS (sizeof(short))
X
Xint ctp_rawinput;            /* total input */
Xint ctp_reply;                /* replies to us */
Xint ctp_forward;            /* packets forwarded */
Xint ctp_multicast;            /* err: forward to multicast!! */
Xint ctp_badfunction;            /* err: bad function */
Xint ctp_errs;                /* other errs */
Xctp_input( h, m, myif )
X    register struct ether_header *h;
X    register struct mbuf *m;
X    struct ifnet *myif;
X{
X    ctp_rawinput++;
X
X    if( !ctp_process( h, m ) )        /* no reply generated?? */
X    m_freem(m);            /* discard buffer */
X}
X
Xstatic ctp_process( h, m, myif )
X    register struct ether_header *h;
X    register struct mbuf *m;
X    struct ifnet *myif;
X{
X    register u_short func, skip;
X    register u_char *cp;
X    register int l;
X
X    struct ether_header *eh;
X    struct sockaddr sa;
X
X    l = m->m_len;            /* get data length */
X    cp = mtod(m, u_char *);        /* get data pointer */
X
X    /****************************************************************
X     * process skip
X     */
X
X    l -= SS;
X    if( l < 0 ) {
X# ifdef DEBUG
X    ctp_msg( h );
X    printf("-- too short for skip\n", skip );
X# endif /* DEBUG defined */
X    ctp_errs++;
X    return( 0 );            /* no reply generated */
X    }
X
X    skip = *SP( cp );            /* get skip */
X    skip = SWAP( skip );        /* byte swap if needed */
X    cp += SS;
X
X    if( skip & 1 ) {
X# ifdef DEBUG
X    ctp_msg( h );
X    printf("-- odd skip %d\n", skip );
X# endif /* DEBUG defined */
X    ctp_errs++;
X    return( 0 );            /* no reply generated */
X    }
X
X    /****************************************************************
X     * process function
X     */
X
X    l -= skip;
X    if( l < 0 ) {
X# ifdef DEBUG
X    ctp_msg( h );
X    printf("-- skip too large (%d.)\n", skip );
X# endif /* DEBUG defined */
X    ctp_errs++;
X    return( 0 );            /* no reply generated */
X    }
X
X    cp += skip;                /* get address of function */
X
X    func = *SP( cp );            /* get function */
X    func = SWAP( func );        /* byte swap if needed */
X
X    l -= SS;                /* deduct function length */
X    cp += SS;                /* advance past function */
X
X    switch( func ) {
X
X    case CTP_REP:            /* reply */
X# ifdef DEBUG
X    ctp_msg( h );
X    printf("-- reply, %d bytes\n", l);
X# endif /* DEBUG defined */
X    /* create AF_CTP and pass up to users?? */
X    ctp_reply++;
X    return( 0 );            /* no reply generated */
X    break;
X
X    case CTP_FWD:
X    l -= sizeof( struct ether_addr );
X    if( l < 0 ) {
X# ifdef DEBUG
X        ctp_msg( h );
X        printf("-- forward too short\n");
X# endif /* DEBUG defined */
X        ctp_errs++;
X        return( 0 );
X    }
X    if( *cp & 1 ) {            /* multicast bit */
X        ctp_msg( h );
X        printf(" -- forward to multicast address ");
X        ether_print( cp );
X        printf(" ignored\n");
X        ctp_multicast++;
X        return( 0 );        /* no reply generated */
X    }
X# ifdef DEBUG
X    ctp_msg( h );
X    printf("-- forwarding %d bytes to ", l);
X    ether_print( cp );
X# endif /* DEBUG defined */
X    skip += SS + sizeof( struct ether_addr ); /* skip forward function */
X                    /* and address */
X    *mtod(m, u_short *) = SWAP( skip ); /* update in packet */
X
X    sa.sa_family = AF_UNSPEC;        /* set family */
X    eh = (struct ether_header *)sa.sa_data;    /* get sockaddr */
X    eh->ether_type = ETHERTYPE_CTP;        /* set ether type */
X    eh->ether_dhost = *(struct ether_addr *) cp; /* copy dest */
X    (myif->if_output)( myif, m, &sa );
X
X    ctp_forward++;
X    return( 1 );            /* AH-HAH!! we generated a reply!! */
X    break;
X
X    default:
X# ifdef DEBUG
X    ctp_msg( h );
X    printf("-- bad function %d.\n", func );
X# endif /* DEBUG defined */
X    ctp_badfunction++;
X    return( 0 );
X    break;
X    }
X    return( 0 );            /* just in case */
X} /* ctp_process */
X
Xctp_msg( h )
X    register struct ether_header *h;
X{
X    printf("CTP packet from ");
X    ether_print( &h->ether_shost );
X} /* ctp_msg */
X
X# endif /* NETHER > 0 */
END_OF_if_ctp.c
if test 5585 -ne `wc -c <if_ctp.c`; then
    echo shar: \"if_ctp.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f nit.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"nit.c\"
else
echo shar: Extracting \"nit.c\" \(5414 characters\)
sed "s/^X//" >nit.c <<'END_OF_nit.c'
X/*
X * Copyright (c) 1988 Philip L. Budne and The Trustees of Boston University
X * All Rights Reserved
X *
X * Permission is granted to any individual or institution to use, copy,
X * or redistribute this software so long as it is not sold for profit,
X * provided that this notice and the original copyright notices are
X * retained.  Boston University makes no representations about the
X * suitability of this software for any purpose.  It is provided "as is"
X * without express or implied warranty.
X */
X# include <sys/types.h>
X# include <sys/time.h>
X# include <sys/socket.h>
X# include <sys/ioctl.h>
X# include <net/nit.h>
X# include <net/if.h>
X# include <stdio.h>
X
X# define GLOBAL
X
X# ifdef DEBUG
X# define IFDEB(x) (x)
X# else /* DEBUG not defined */
X# define IFDEB(x)
X# endif /* DEBUG not defined */
X
X# define ALIGNSIZE sizeof( int )
X# define ALIGN(a) (((a) + ALIGNSIZE - 1) & ~(ALIGNSIZE - 1))
X/* NITBUFSIZ == 1K */
X# define BUFSPACE (NITBUFSIZ * 256)
X# define CHUNKSIZE (NITBUFSIZ * 64)
X/****************************************************************/
X
X
XGLOBAL int nit_errors = 1;        /* display errors */
XGLOBAL int nit_exit = 1;        /* exit on errors */
XGLOBAL int nit_bufspace = BUFSPACE;
XGLOBAL int nit_chunksize = CHUNKSIZE;
XGLOBAL int nit_snaplen = 2000;
X
Xtypedef void (*FPTR)();
X
XGLOBAL int
Xnit_loop( s, input_handlr )
X    int s;
X    FPTR input_handlr;
X{
X    for( ;; ) {
X    static char buf[ BUFSPACE ];
X    register char *pp;
X    register struct nit_hdr *nh;
X    char *pe;
X    int cc;
X
X    cc = read( s, buf, sizeof( buf ) );
X    if( cc < sizeof( struct nit_hdr ) ) {
X        if( nit_errors )
X        fprintf(stderr, "nit_loop: short read (%d)\n", cc );
X        if( nit_exit )
X        exit( 1 );
X        else
X        return( -1 );
X    } /* short read */
X
X    pp = buf;
X    pe = pp + cc;
X    while( pp < pe ) {
X        nh = (struct nit_hdr *) pp;
X        cc = process_nh( s, nh, input_handlr );
X        if( cc < 0 )
X        break;
X        else
X        pp += ALIGN( sizeof( struct nit_hdr ) + cc );
X    } /* while */
X    } /* for ever */
X} /* nit_process */
X
Xstatic int
Xprocess_nh( s, nh, input_handlr )
X    int s;
X    struct nit_hdr *nh;
X    FPTR input_handlr;
X{
X    switch( nh->nh_state ) {
X    case NIT_QUIET:
X    IFDEB( fprintf(stderr, "quiet\n") );
X    return( 0 );
X
X    case NIT_CATCH:
X    (*input_handlr)( s, nh );
X    return( nh->nh_datalen );
X
X    case NIT_NOMBUF:
X    fprintf(stderr, "out of mbufs, dropped %d packets\n",
X        nh->nh_dropped );
X    return( 0 );
X
X    case NIT_NOCLUSTER:
X    fprintf(stderr, "out of mclusters, dropped %d packets\n",
X        nh->nh_dropped );
X    return( 0 );
X
X    case NIT_NOSPACE:
X    fprintf(stderr, "bufspace exceeded, dropped %d packets\n",
X        nh->nh_dropped );
X    return( 0 );
X
X    case NIT_SEQNO:
X    IFDEB( fprintf(stderr, "seqno %d\n", nh->nh_seqno ) );
X    return( 0 );
X
X    default:
X    fprintf(stderr, "bad NIT state: %d\n", nh->nh_state );
X    return( -1 );
X    } /* switch */
X}
X
XGLOBAL int
Xnit_open( ifa, type, la, pro )
X    char *ifa;
X    unsigned int type;
X    u_char *la;
X    int pro;
X{
X    struct sockaddr_nit snit;
X    struct nit_ioc nioc;
X    struct ifreq ifr;
X    int s;
X
X    if( ifa == NULL ) {
X    if( nit_errors )
X        fprintf( stderr, "nit_open: must have interface pointer\n" );
X    if( nit_exit )
X        exit( 1 );
X    else
X        return( -1 );
X    } /* no ifa */
X
X    if( (s = socket(AF_NIT, SOCK_RAW, NITPROTO_RAW)) < 0 ) {
X    if( nit_errors )
X        perror( "socket" );
X    if( nit_exit )
X        exit( 1 );
X    else
X        return( -1 );
X    } /* socket */
X
X    if( *ifa == '\0' ) {        /* no interface specified */
X    struct ifconf ifc;
X    char ifbuf[ 100 ];
X
X    ifc.ifc_len = sizeof( ifbuf );
X    ifc.ifc_buf = ifbuf;
X
X    if( ioctl(s, SIOCGIFCONF, (char *)&ifc) < 0 ) {
X        if( nit_errors )
X        perror( "ifconf ioctl");
X        close( s );
X        if( nit_exit )
X        exit( 1 );
X        else
X        return( -1 );
X    } /* ifconf failed */
X    strcpy( ifa, ifc.ifc_req->ifr_name ); /* copy back to buffer */
X    } /* try to find an interface */
X
X    snit.snit_family = AF_NIT;
X    strncpy( snit.snit_ifname, ifa, sizeof(snit.snit_ifname ) );
X    if( bind(s, (struct sockaddr *)&snit, sizeof( snit ) ) < 0 ) {
X    if( nit_errors )
X        perror( ifa );
X    close( s );
X    if( nit_exit )
X        exit( 1 );
X    else
X        return( -1 );
X    } /* bind failed */
X
X    bzero(&nioc, sizeof(nioc));
X    nioc.nioc_bufspace = nit_bufspace;
X    nioc.nioc_chunksize = nit_chunksize;
X    nioc.nioc_typetomatch = type;
X    nioc.nioc_snaplen = nit_snaplen;
X    nioc.nioc_bufalign = ALIGNSIZE;
X    nioc.nioc_bufoffset = 0;
X    nioc.nioc_flags = (pro ? NF_PROMISC : 0 ) | NF_TIMEOUT;
X    nioc.nioc_timeout.tv_sec = 1;
X    nioc.nioc_timeout.tv_usec = 0;
X    if (ioctl(s, SIOCSNIT, &nioc) != 0) {
X    if( nit_errors )
X        perror("nit ioctl");
X    close( s );
X    if( nit_exit )
X        exit(1);
X    else
X        return( -1 );
X    } /* nit ioctl */
X
X    strncpy(ifr.ifr_name, ifa, sizeof ifr.ifr_name);
X    if( ioctl(s, SIOCGIFADDR, (caddr_t) &ifr) < 0 ) {
X    if( nit_errors )
X        fprintf(stderr, "cannot find ether address for %s\n", ifa );
X    close( s );
X    if( nit_exit )
X        exit( 1 );
X    else
X        return( -1 );
X    } /* interface address ioctl */
X    bcopy( ifr.ifr_addr.sa_data, la, 6 );
X    return( s );
X} /* nit_open */
X
XGLOBAL int
Xnit_output(fd, buf, len)
X    int fd, len;
X    char *buf;
X{
X    struct sockaddr sa;
X    int offset = sizeof(sa.sa_data);
X    int result;
X
X    sa.sa_family = AF_UNSPEC;
X    bcopy(buf, sa.sa_data, offset);
X    result = sendto(fd, buf+offset, len-offset, 0, &sa, sizeof(sa));
X    if( result < 0 )
X    return( result );
X    return( result+offset );
X} /* nit_output */
END_OF_nit.c
if test 5414 -ne `wc -c <nit.c`; then
    echo shar: \"nit.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f packet.h -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"packet.h\"
else
echo shar: Extracting \"packet.h\" \(6347 characters\)
sed "s/^X//" >packet.h <<'END_OF_packet.h'
X/*
X * Copyright (c) 1988 Philip L. Budne and The Trustees of Boston University
X * All Rights Reserved
X *
X * Permission is granted to any individual or institution to use, copy,
X * or redistribute this software so long as it is not sold for profit,
X * provided that this notice and the original copyright notices are
X * retained.  Boston University makes no representations about the
X * suitability of this software for any purpose.  It is provided "as is"
X * without express or implied warranty.
X */
Xtypedef unsigned char byte;
Xtypedef unsigned short u_short;
Xtypedef unsigned long ip_addr;
Xtypedef unsigned long u_long;
Xtypedef byte EA[6];
X
X/****************************************************************/
Xstruct ipheader {
X# ifdef SWAP
X    int ip_ihl : 4;        /* Internet header length in 32 bit words */
X    int ip_ver : 4;        /* Header version */
X# else /* SWAP not defined */
X    int ip_ver : 4;        /* Header version */
X    int ip_ihl : 4;        /* Internet header length in 32 bit words */
X# endif /* SWAP not defined */
X    byte ip_tsrv;        /* Type of service */
X    u_short ip_len;        /* Total packet length including header */
X    u_short ip_id;        /* ID for fragmentation */
X# ifdef SWAP
X    u_short ip_foff : 13;    /* Fragment offset */
X    u_short ip_flgs : 3;    /* flags */
X# else /* SWAP not defined */
X    u_short ip_flgs : 3;    /* flags */
X    u_short ip_foff : 13;    /* Fragment offset */
X# endif /* SWAP not defined */
X# define IP_FLG_DF 01
X# define IP_FLG_MF 02
X
X    byte ip_ttl;        /* Time to live (secs) */
X    byte ip_prot;        /* protocol */
X    u_short ip_chksum;        /* Header checksum */
X    ip_addr ip_src;        /* Source addrt */
X    ip_addr ip_dst;        /* Destination addr */
X    byte ip_options[1];        /* options... */
X};
X                    /* from RFC990 */
X# define IP_PROT_ICMP    1        /* control messages */
X# define IP_PROT_GGP    2        /* gave vs gate */
X                    /* 5 - ST - stream */
X# define IP_PROT_TCP    6        /* tcp */
X# define IP_PROT_EGP    8        /* ext gateways */
X                    /* 9 - any igp */
X# define IP_PROT_PUP    12        /* pup */
X                    /* 13 - ARGUS */
X                    /* 14 - EMCON */
X                    /* 15 - XNET - cross net debugger */
X                    /* 16 - Chaos */
X# define IP_PROT_UDP    17        /* user datagrams */
X                    /* 18 - MUX - Multiplexing */
X                    /* 19 - DCN-MEAS */
X                    /* 20 - HMP host monitoring */
X                    /* 21 PRM */
X# define IP_PROT_IDP    22        /* xns idp */
X                    /* 23 TRUNK1 */
X                    /* 24 TRUNK2 */
X                    /* 25 LEAF1 */
X                    /* 26 LEAF2 */
X                    /* 27 RDP */
X                    /* 28 IRTP - reliable transaction */
X                    /* 29 ISO-TP4 */
X                    /* 30 NETBLT */
X                    /* 61 any host internal protocol */
X                    /* 62 CFTP */
X                    /* 63 any local network */
X                    /* 64 SAT-EXPAK */
X                    /* 65 MIT-SUBNET */
X                    /* 66 - RVD */
X                    /* 67 IPPC */
X                    /* 68 any DFS */
X                    /* 69 SAT-MON */
X                    /* 71 IPCV */
X                    /* 76 BR-SAT-MON */
X                    /* 78 WB-MON */
X                    /* 79 WB-EXPAK */
X# define IP_PROT_ND    77        /* net disk (SUN, unoff) */
X
X
X/****************************************************************/
Xstruct udpheader {
X    u_short udp_srcp;            /* source port */
X    u_short udp_dstp;            /* dest port */
X    u_short udp_len;            /* length of UDP packet */
X    u_short udp_cksum;            /* UDP checksum */
X};
X
X/****************************************************************/
Xstruct tcpheader {            /* a tcp header */
X    u_short tcp_srcp;            /* source port */
X    u_short tcp_dstp;            /* dest port */
X    u_long tcp_seq;            /* sequence number */
X    u_long tcp_ack;            /* acknowledgement number */
X# if 0
X    u_short tcp_flags;
X# define tcp_thl    tcp_flags >> 12
X# define tcp_fin    tcp_flags & 001
X# define tcp_syn    tcp_flags & 002
X# define tcp_rst    tcp_flags & 004
X# define tcp_psh    tcp_flags & 010
X# define tcp_fack    tcp_flags & 020
X# define tcp_furg    tcp_flags & 040
X# else /* not 0 */
X    unsigned tcp_thl : 4;        /* tcp header length */
X    unsigned tcp_uu1 : 6;        /* unused */
X    unsigned tcp_furg : 1;        /* urgent ptr. valid */
X    unsigned tcp_fack : 1;        /* ack valid */
X    unsigned tcp_psh : 1;        /* push bit */
X    unsigned tcp_rst : 1;        /* reset bit */
X    unsigned tcp_syn : 1;        /* syn bit */
X    unsigned tcp_fin : 1;        /* fin bit */
X# endif /* not 0 */
X    u_short tcp_win;            /* window */
X    u_short tcp_cksum;            /* checksum */
X    u_short tcp_urg;            /* urgent pointer */
X};
X
X/****************************************************************/
Xstruct ndpacket {
X    byte nd_op, nd_dev, nd_err, nd_ver;
X    u_long nd_seq, nd_blk, nd_count, nd_res, nd_off, nd_data;
X};
X
X/****************************************************************/
Xstruct arppacket {
X    u_short    arp_hw;            /* should be 1 */
X    u_short    arp_pro;
X    byte    arp_hln;        /* hdw addr len */
X    byte    arp_pln;        /* proto addr len */
X    u_short    arp_op;            /* arp opcode */
X    byte    arp_data[1];        /* data... */
X/*  EA        arp_xsha;        /* sender hardware address */
X/*  ip_addr    arp_xspa;        /* sender protocol address */
X/*  EA        arp_xtha;        /* target hardware address */
X/*  ip_addr    arp_xtpa;        /* target protocol address */
X};
X
X# define ARP_REQUEST    1        /* request to resolve address */
X# define ARP_REPLY    2        /* response to previous request */
X# define RARP_REQUEST    3        /* request to resolve address */
X# define RARP_REPLY    4        /* response to previous request */
X
X/* as of rfc990 */
X# define ARP_HW_ETHER    1        /* 10mb ether */
X# define ARP_HW_XETHER    2        /* 3mb ether */
X# define ARP_HW_AX25    3        /* amateur radio */
X# define ARP_HW_PRONET    4
X# define ARP_HW_CHAOS    5
X# define ARP_HW_IEEE802    6
X
X/****************************************************************/
Xstruct puppacket {
X    u_short pup_len;
X    byte pup_transport;
X    byte pup_type;
X    u_long pup_id;
X    struct {
X    byte pup_port_net;
X    byte pup_port_host;        /* swapped? */
X    u_short pup_port_sock1, pup_port_sock2;
X    } pup_src, pup_dst;
X};
X
X/****************************************************************/
Xstruct xns_addr {
X    byte xnsa_net[4];
X    byte xnsa_host[6];
X    u_short xnsa_port;
X};
X
Xstruct xnspacket {            /* xns idp */
X    u_short xns_sum, xns_len;        /* cksum, len */
X    byte xns_tc, xns_pt;        /* hops(transport), packet type */
X    struct xns_addr xns_dst;
X    struct xns_addr xns_src;
X};
X/****************************************************************/
X
Xunion {
X    byte p_bytes[ 2000 ];
X    struct etherpacket {
X    EA e_dst;
X    EA e_src;
X    u_short e_type;
X    union {
X        byte d_bytes[1];
X        struct ipheader  d_ip;
X        struct arppacket d_arp;
X        struct puppacket d_pup;
X        struct xnspacket d_xns;
X    } e_data;
X    } p_ether;
X} packet;
END_OF_packet.h
if test 6347 -ne `wc -c <packet.h`; then
    echo shar: \"packet.h\" unpacked with wrong size!
fi
# end of overwriting check
fi
if test -f rlog.c -a "${1}" != "-c" ; then
  echo shar: Will not over-write existing file \"rlog.c\"
else
echo shar: Extracting \"rlog.c\" \(20469 characters\)
sed "s/^X//" >rlog.c <<'END_OF_rlog.c'
X/*
X * Copyright (c) 1988 Philip L. Budne and The Trustees of Boston University
X * All Rights Reserved
X *
X * Permission is granted to any individual or institution to use, copy,
X * or redistribute this software so long as it is not sold for profit,
X * provided that this notice and the original copyright notices are
X * retained.  Boston University makes no representations about the
X * suitability of this software for any purpose.  It is provided "as is"
X * without express or implied warranty.
X */
X# include <stdio.h>
X# include <ctype.h>
X# include "packet.h"
X
X# define EP_PUP        0x0200
X# define EP_XNS        0x0600
X# define EP_IP        0x0800
X# define EP_CHAOS    0x0804
X# define EP_ARP        0x0806
X# define EP_TRAIL    0x1000        /* TO DO! */
X# define EP_RARP    0x8035        /* TO DO! */
X# define EP_CTP        0x9000
X
Xint    dumpdata = 1;
Xint    indent = 0;
X
X/* counts: */
Xint    count        = 0;
Xint     ipcount    = 0;
Xint      icmpcount    = 0;
Xint      tcpcount    = 0;
Xint      udpcount    = 0;
Xint      ndcount    = 0;
Xint      ippupcount    = 0;
Xint      ipidpcount    = 0;
Xint      egpcount    = 0;
Xint      ggpcount    = 0;
Xint      ipfragcount   = 0;
Xint      ipothercount    = 0;
Xint      ipbadvercount    = 0;
Xint     arpcount    = 0;
Xint     rarpcount    = 0;
Xint     ieeecount    = 0;
Xint     pupcount    = 0;
Xint     xnscount    = 0;
Xint     othercount    = 0;
Xint     ctpcount    = 0;
X
X/****************************************************************/
X# include "protocol.h"
Xint pr_count[ NPROTO ];
X/****************************************************************/
X
Xint pc;                    /* packet byte count */
X
Xmain() {
X    char line[ 4096 ];
X    register byte *pp;
X    register char *lp;
X
X    pc = 0;
X    pp = packet.p_bytes;
X    while( gets( line ) ) {
X    if( line[0] == ' ' || line[0] == '*' || line[0] == '\0' ) {
X        if( pc > 0 )
X        process();
X        pp = packet.p_bytes;
X        pc = 0;
X        continue;
X    }
X
X    for( lp = line; *lp; lp++ ) {
X        if( isspace( *lp ) )
X        continue;
X        else if( isxdigit( *lp ) && isxdigit( lp[1] ) ) {
X        *pp++ = xval( *lp, lp[1] );
X        lp++;
X        pc++;
X        }
X        else
X        fprintf( stderr, "you lose: %s\n", lp );
X    }
X    }
X    if( pc > 0 )
X    process();
X    dump_stats();
X}
X
Xprocess() {
X    register struct etherpacket *e = (struct etherpacket *) &packet;
X    u_short type;
X
X    count++;
X
X    terpri();
X    printf("Packet #%d\n", count );
X
X    type = packet.p_ether.e_type;
X    printf("Ether type %02X-%02X len %d ",
X       (type >> 8) & 255, type & 255, pc );
X
X
X    petaddr( e->e_src );
X    putchar(' ');
X    putchar('>');
X    putchar(' ');
X    petaddr( e->e_dst );
X    terpri();
X
X    switch( type ) {
X    case EP_PUP:
X    process_pup();
X    break;
X    case EP_IP:
X    process_ip( 1, &packet.p_ether.e_data.d_ip );
X    break;
X    case EP_ARP:
X    process_arp();
X    break;
X    case EP_RARP:
X    process_rarp();
X    break;
X    case EP_XNS:
X    process_xns();
X    break;
X    case EP_CTP:
X    process_ctp();
X    break;
X    default:
X# ifdef IEEE
X    if( packet.p_ether.e_type < 0x0600 )
X        process_ieee( type );
X    else
X# endif /* IEEE defined */
X        process_other( type );
X    break;
X    }
X    fflush( stdout );
X    fflush( stderr );
X}
X
Xprocess_ip( live, i )
X    int live;                /* true if a real packet */
X                    /* false for icmp sent headers */
X    register struct ipheader *i;
X{
X    register byte *d, *op;
X    int size;
X
X    if( live)
X    ipcount++;
X
X    if( i->ip_ver != 4 ) {
X    printf("IP version not 4 (%d)", i->ip_ver );
X    terpri();
X    ipbadvercount++;
X    return;
X    }
X
X    printf("IP ");
X    pipaddr( 1, i->ip_src );
X    printf(" > ");
X    pipaddr( 1, i->ip_dst );
X
X    printf(" len %d",i->ip_len );
X
X    if( i->ip_flgs & IP_FLG_DF )    /* don't frag */
X    printf(" df");
X
X    if( i->ip_flgs & IP_FLG_MF )    /* more frags/last frag */
X    printf(" mf");
X
X/*    if( i->ip_ttl != 0 && i->ip_ttl != 255 ) /**/
X    printf(" ttl %d", i->ip_ttl );
X
X    if( i->ip_tsrv != 0 ) {
X    if( (i->ip_tsrv>>5) & 07 )
X        printf(" prec %d", ((i->ip_tsrv>>5) & 07) );
X    if( i->ip_tsrv & 020 )
X        printf(" low_delay");
X    if( i->ip_tsrv & 010 )
X        printf(" hi_thruput");
X    if( i->ip_tsrv & 04 )
X        printf(" hi_rely");
X    }
X
X    /* more frags or offset? */
X    printf(" id %d", i->ip_id );
X    printf(" off %d", i->ip_foff << 3 );
X
X    if( (i->ip_flgs & (IP_FLG_MF|IP_FLG_DF)) || i->ip_foff != 0 ) {
X    if( i->ip_foff ) {
X        if( live )
X        ipfragcount++;
X    }
X    }
X    terpri();
X
X    d = ((byte *)(i)) + (i->ip_ihl << 2); /* point to data */
X
X    /* options processing!! never tested */
X    op = i->ip_options;
X    while( op < d ) {
X    if( *op & 0200 )
X        printf(" copy");
X
X    switch( ((*op)>>5)&03 ) {    /* print option class */
X                    /* perhaps only for unkn types? */
X    case 0:
X        printf(" control");
X        break;
X    case 2:
X        printf(" debug/meas");
X        break;
X    case 1:
X        printf(" reserved1");
X        break;
X    case 3:
X        printf(" reserved3");
X        break;
X    }
X
X    switch( (*op) & 017 ) {
X    case 0:                /* end of list */
X        goto end_of_options;
X
X    case 1:
X        printf(" noop");
X        op++;
X        break;
X
X    case 2:
X        printf(" security %02X %02X", op[2], op[3] );
X        op += op[1];            /* should be 11 */
X        break;
X
X    case 3:
X        printf(" LS+RR");        /* loose source */
X        /* print more info! */
X        op += op[1];
X        break;
X
X    case 4:
X        printf(" TIMESTAMP");
X        switch( op[3] &0xf ) {
X        case 0:
X        break;            /* time stamps only */
X        case 1:
X        printf("+ADDRESS");
X        break;
X
X        case 2:
X        printf(" ?flag 2?");
X        break;
X
X        case 3:
X        printf(" (prespec)");
X        break;
X        }
X
X        if( op[3] & 0xf0 )
X        printf(" %d overflows", (op[3]>>4)&0xf );
X
X        op += op[1];
X        break;
X
X    case 7:
X        printf(" RR");
X        /* print more info! */
X        op += op[1];
X        break;
X
X    case 8:
X        printf(" SATNET_Stream_ID");
X        /* print more info! */
X        op += op[1];            /* should be 4 */
X        break;
X
X    case 9:
X        printf(" SS+RR");        /* strict source */
X        /* print more info! */
X        op += op[1];
X        break;
X
X    default:
X        printf(" option %d.", *op&017 );
X        op += op[1];
X        break;
X    } /* switch on option number */
X    terpri();
X    } /* while op */
X
Xend_of_options: ;
X
X    if( i->ip_foff != 0 && live ) {
X    printf("  FRAGMENT (proto %d.)", i->ip_prot );
X    terpri();
X    return;                /* ?? */
X    }
X
X    size = pc - (d - packet.p_bytes);
X
X    switch( i->ip_prot ) {
X    case IP_PROT_UDP:
X    if( live )
X        udpcount++;
X    process_ip_udp( d, size );
X    break;
X    case IP_PROT_TCP:
X    if( live )
X        tcpcount++;
X    process_ip_tcp( d, size );
X    break;
X    case IP_PROT_ND:
X    if( live )
X        ndcount++;
X    process_ip_nd( d, size );
X    break;
X    case IP_PROT_ICMP:
X    if( live )
X        icmpcount++;
X    process_ip_icmp( d );
X    break;
X    case IP_PROT_GGP:
X    printf("GGP");
X    terpri();
X    if( live )
X        ggpcount++;
X    /* process?? */
X    break;
X    case IP_PROT_EGP:
X    printf("EGP");
X    terpri();
X    if( live )
X        egpcount++;
X    /* process?? */
X    break;
X    case IP_PROT_PUP:
X    printf("PUP-IP");
X    terpri();
X    if( live )
X        ippupcount++;
X    break;
X    case IP_PROT_IDP:            /* xns idp */
X    printf("IDP-IP (xns)");
X    terpri();
X    if( live )
X        ipidpcount++;
X    /* process?? */
X    break;
X    default:
X    printf(" ipproto %d", i->ip_prot );
X    terpri();
X    if( live )
X        ipothercount++;
X    }
X}
X
Xprocess_ip_udp( d )
Xbyte *d;
X{
X    register struct udpheader *u = (struct udpheader *) d;
X    printf("UDP srcp: %d destp: %d", u->udp_srcp, u->udp_dstp );
X    terpri();
X}
X
Xprocess_ip_tcp( d, size )
Xbyte *d;
X{
X    register struct tcpheader *t = (struct tcpheader *) d;
X    register byte *o, *td;
X    int c, l;
X
X    printf("TCP srcp: %d destp: %d", t->tcp_srcp, t->tcp_dstp );
X
X    if( t->tcp_furg )
X    printf(" urg %#x", t->tcp_urg );
X    if( t->tcp_fack )
X    printf(" ack %#x", t->tcp_ack );
X    if( t->tcp_psh )
X    printf(" psh");
X    if( t->tcp_rst )
X    printf(" rst");
X    if( t->tcp_syn )
X    printf(" syn");
X    if( t->tcp_fin )
X    printf(" fin");
X    printf(" window %d.", t->tcp_win );
X
X    c = ((t->tcp_thl) << 2);        /* get tcp data offset */
X
X    size -= c;                /* get size of data */
X    td = d + c;                /* start of tcp data */
X
X    printf(" data %d.", size );
X
X    o = d + sizeof( struct tcpheader );    /* get start of options */
X    c -= sizeof( struct tcpheader );    /* get size of options */
X
X    while( c > 0 ) {            /* process tcp options */
X    switch( *o ) {
X    case 0:                /* end of list */
X        goto break_options_loop;
X
X    case 1:                /* nop */
X        l = 1;
X        break;
X
X    case 2:                /* mss */
X        l = o[1];
X        if( l != 4 ) {
X        printf("BAD_mss");
X        }
X        else
X        printf(" mss %d", *((u_short *)(&o[2])) );
X        break;
X
X    default:
X        l = o[1];
X        printf(" option %d. (len %d.)", *o, l );
X        break;
X    } /* switch */
X    o += l;
X    c -= l;
X    } /* tcp options loop */
X break_options_loop:;
X
X    terpri();
X
X    if( dumpdata ) {
X    while( size-- > 0 )
X        putbyte( *td++ );
X    terpri();
X    }
X} /* process_ip_tcp */
X
Xputbyte( c ) {
X    if( c >= ' ' && c <= 0176 )
X    putchar( c );
X    else
X    switch( c ) {
X    case '\n':
X        printf("\\n");
X        break;
X    case '\r':
X        printf("\\r");
X        break;
X    case '\f':
X        printf("\\f");
X        break;
X    /* ** MORE ESCAPES ** @@ */
X    default:
X        printf("\\%#o", c & 0xff );
X        break;
X    } /* switch */
X} /* putbyte */
X
Xprocess_ip_icmp( d )
Xbyte *d;
X{
X    register struct icmppacket {
X    byte icmp_type, icmp_code;
X    u_short icmp_cksum;
X    union {
X        u_short id_short[2];
X        u_long  id_long[1];
X        byte    id_byte[4];
X    } icmp_data;
X    struct ipheader icmp_ip;
X    } *i = (struct icmppacket *) d;
X
X    static char *icmp_unreach_names[] = {
X    "net", "host", "proto", "port", "need frag", "srcroute failed" };
X# define N_ICMP_UNREACH_NAMES (sizeof( icmp_unreach_names ) / sizeof( char * ))
X
X    printf("ICMP ");
X    switch( i->icmp_type ) {
X    case 0:                /* ECHOREPLY */
X    case 8:                /* ECHO */
X    printf("echo");
X    if( i->icmp_type == 0 )
X        printf(" reply");
X    printf(" id %d seq %d data: ",
X           i->icmp_data.id_short[0], i->icmp_data.id_short[1] );
X    pbytes( &i->icmp_data.id_byte[4], 16 );
X    terpri();
X    return;
X    break;
X
X    case 3:                /* ICMP_UNREACH */
X    if( i->icmp_code < N_ICMP_UNREACH_NAMES )
X        printf("unreachable %s", icmp_unreach_names[ i->icmp_code ] );
X    else
X        printf("unreachable (code %d)", i->icmp_code );
X    break;
X
X    case 4:
X    printf("source quench");
X    break;
X
X    case 5:                /* ICMP_REDIRECT */
X    printf("redirect");
X    if( i->icmp_code == 0 )
X        printf(" net");
X    else if( i->icmp_code == 1 )
X        printf(" host");
X    else if( i->icmp_code == 2 )
X        printf(" tos/net");
X    else if( i->icmp_code == 3 )
X        printf(" tos/host");
X    else
X        printf(" (code %d)", i->icmp_code );
X    printf(" to ");
X    pipaddr( 1, i->icmp_data.id_long[0] );
X    break;
X
X    case 11:
X    switch( i->icmp_code ) {
X    case 0:
X        printf("ttl exceeded");
X        break;
X    case 1:
X        printf("reassembly ttl exceeded");
X        break;
X    default:
X        printf("time exceeded code %d", i->icmp_code );
X        break;
X    }
X    break;
X
X    case 12:
X    printf("parmeter problem at %d", i->icmp_data.id_byte[0] );
X    break;
X
X    case 13:
X    case 14:
X    printf("timestamp");
X    if( i->icmp_type == 14 )
X        printf(" reply");
X    printf(" id %d seq %d",
X           i->icmp_data.id_short[0], i->icmp_data.id_short[1] );
X    terpri();
X    printf("orig ");
X    ptime( i->icmp_data.id_long[1] );
X
X    if( i->icmp_type == 14 ) {    /* reply */
X        printf(" rcv ");
X        ptime( i->icmp_data.id_long[2] );
X        printf(" xmit ");
X        ptime( i->icmp_data.id_long[3] );
X    }
X    terpri();
X    return;
X    break;
X
X    case 15:
X    printf("info request id %d seq %d",
X           i->icmp_data.id_short[0], i->icmp_data.id_short[1] );
X    terpri();
X    return;
X    break;
X
X    case 16:
X    printf("info reply id %d seq %d",
X           i->icmp_data.id_short[0], i->icmp_data.id_short[1] );
X    terpri();
X    return;
X    break;
X
X    case 17:
X    printf("mask request id %d seq %d",
X           i->icmp_data.id_short[0], i->icmp_data.id_short[1] );
X    terpri();
X    return;                /* no enacpsulated packet */
X    break;
X
X    case 18:
X    printf("mask reply id %d seq %d ",
X           i->icmp_data.id_short[0], i->icmp_data.id_short[1] );
X    pipaddr( 0, i->icmp_data.id_long[1] );
X    terpri();
X    return;                /* no enacpsulated packet */
X    break;
X
X    default:
X    printf("type %d", i->icmp_type );
X    if( i->icmp_code != 0 )
X        printf(" (code %d)", i->icmp_code );
X    printf(" data: ");
X    pbytes( i->icmp_data.id_byte, 4 );
X    terpri();
X    return;                /* no enacpsulated packet?? */
X    break;
X    }
X
X    indent += 4;
X    terpri();
X    process_ip( 0, &i->icmp_ip );    /* RECURSE!! */
X    indent -= 4;
X    terpri();
X}
X
Xptime( t )
Xu_long t;
X{
X    int h, m, s;
X    if( t & 0x40000000 ) {
X    printf( "%d.", t & 0xbfffffff );
X    return;
X    }
X    s = t / 1000;
X    m = s / 60;
X    h = m / 60;
X
X    m %= 60;
X    s %= 60;
X    t %= 1000;
X    if( h > 0 )
X    printf("%dh", h );
X    if( m > 0 )
X    printf("%dm", m  );
X    printf("%d.%03d", s, t );
X}
X
Xprocess_ip_nd( d )
Xbyte *d;
X{
X    register struct ndpacket *n = (struct ndpacket *) d;
X
X    printf("ND");
X
X    switch( n->nd_op & 7 ) {
X    case 1:
X    printf(" read");
X    break;
X    case 2:
X    printf(" write");
X    break;
X    case 3:
X    printf(" error");
X    break;
X    default:
X    printf(" op %d", n->nd_op & 7 );
X    break;
X    }
X    if( n->nd_op & 010 )
X    printf(" wait");
X    if( n->nd_op & 020 )
X    printf(" done");
X
X    printf(" /dev/nd");
X    if( n->nd_dev > 0177 )
X    putchar('l');
X    else if( n->nd_dev > 077 )
X    putchar('p');
X    printf("%d seq %d",  n->nd_dev & 077, n->nd_seq );
X    printf(" block %d count %d",
X       n->nd_blk, n->nd_count);
X    if( n->nd_res > 0 )
X    printf(" resid %d", n->nd_res );
X    if( n->nd_off > 0 )
X    printf(" off %d",
X           n->nd_off );
X    if( n->nd_data > 0 )
X    printf(" data %d",
X           n->nd_data );
X    terpri();
X}
X
Xprocess_arp() {
X    arpcount++;
X    printf("ARP");
X    process_arp2(0);
X}
X
X# define EA_NZERO(p) ( (*(long *)p) != 0 && (*(short *)(p+4)) != 0 )
X
Xprocess_arp2(israrp) {
X    register struct arppacket *a = &packet.p_ether.e_data.d_arp;
X    register struct protocol *pp;
X    int xsha, xspa, xtha, xtpa;
X    ip_addr i;
X
X    xsha = 0;                /* sender hdw addr */
X    xspa = a->arp_hln;            /* sender proto addr */
X    xtha = xspa + a->arp_pln;        /* target hdw addr */
X    xtpa = xtha + a->arp_hln;        /* target proto addr */
X
X    switch( a->arp_hw ) {
X    case ARP_HW_ETHER:
X    break;
X    case ARP_HW_XETHER:
X    printf(" 3Mb ether");
X    break;
X    case ARP_HW_AX25:
X    printf(" AX.25");
X    break;
X    case ARP_HW_PRONET:
X    printf(" PROnet");
X    break;
X    case ARP_HW_CHAOS:
X    printf(" Chaos");
X    break;
X    case ARP_HW_IEEE802:
X    printf(" IEEE 802");
X    break;
X    }
X
X    switch( a->arp_pro ) {
X    case EP_IP:
X    case EP_TRAIL:
X    printf(" IP");
X    if( a->arp_pro == EP_TRAIL )
X        printf(" trailers");
X    if( a->arp_op == ARP_REQUEST )
X        printf(" request ");
X    else if( a->arp_op == RARP_REQUEST )
X        printf(" reverse request ");
X    else if( a->arp_op == RARP_REPLY )
X        printf(" reverse reply ");
X    else
X        printf(" op %d ", a->arp_op );
X
X    printf("source");
X    if( EA_NZERO( a->arp_data + xsha ) ) {
X        putchar(' ');
X        petaddr( a->arp_data + xsha );
X    }
X    i = * (ip_addr *) (a->arp_data + xspa);
X    if( i != 0 ) {
X        putchar(' ');
X        pipaddr( 1, i );
X    }
X    terpri();
X
X    printf("target");
X    if( EA_NZERO( a->arp_data + xtha ) ) {
X        putchar(' ');
X        petaddr( a->arp_data + xtha );
X    }
X    i = * (ip_addr *) (a->arp_data + xtpa);
X    if( i != 0 ) {
X        putchar(' ');
X        pipaddr( 1, i );
X    }
X    terpri();
X    return;
X
X    case EP_CHAOS:
X    printf(" CHAOS ");
X    if( a->arp_op == ARP_REQUEST )
X        printf(" request ");
X    else if( a->arp_op == ARP_REPLY )
X        printf(" reply to ");
X    else
X        printf("op %d ", a->arp_op );
X
X    printf("source ");
X    petaddr( a->arp_data + xsha );
X    putchar( ' ' );
X    printf("%#o ", * (u_short *) (a->arp_data + xspa) );
X    terpri();
X
X    printf("target ");
X    petaddr( a->arp_data + xtha );
X    putchar(' ');
X    printf("%#o ", * (u_short *) (a->arp_data + xtpa) );
X    terpri();
X
X    return;
X
X    default:
X    for( pp = protocols; pp->pr_type != 0; pp++ )
X        if( a->arp_pro == pp->pr_type ) {
X        printf("%s ???", pp->pr_name );
X        terpri();
X        return;
X        }
X    printf("%02X-%02X ???", (a->arp_pro >> 8) & 255,
X           a->arp_pro & 255 );
X    terpri();
X    }
X}
X
Xprocess_ieee( l )
Xu_short l;
X{
X    ieeecount++;
X    printf("IEEE len %d", l );
X    terpri();
X}
X
Xprocess_pup() {
X    register struct puppacket *p = &packet.p_ether.e_data.d_pup;
X    pupcount++;
X    printf("PUP len %d transport %d type %#o id %d",
X       p->pup_len, p->pup_transport, p->pup_type );
X    terpri();
X    printf("src net %#o host %#o socket %#o",
X       p->pup_src.pup_port_net,
X       p->pup_src.pup_port_host,
X       (p->pup_src.pup_port_sock1) << 16 +
X       p->pup_src.pup_port_sock2 );
X    terpri();
X    printf("dst net %#o host %#o socket %#o",
X       p->pup_dst.pup_port_net,
X       p->pup_dst.pup_port_host,
X       (p->pup_dst.pup_port_sock1) << 16 +
X       p->pup_dst.pup_port_sock2 );
X    terpri();
X}
X
Xprocess_rarp() {
X    rarpcount++;
X    printf("RARP");
X    process_arp2(1);
X}
X
X# define CTP_REP 1
X# define CTP_FWD 2
X# define CTP_SHORT(sp) (*sp | (sp[1]<<8))
X
Xprocess_ctp() {
X    byte *p2, *p = packet.p_ether.e_data.d_bytes;
X    short f, skip;
X    int len, l2;
X
X    ctpcount++;
X    skip = CTP_SHORT(p);
X    p2 = p + skip + 2;            /* point to data (skip skip!) */
X    len = pc - 14 - skip - 2;        /* length of data */
X
X    printf("CTP skip %d.", skip );
X    terpri();
X    for( ; ; ) {
X    if( len < 2 )
X        return;
X
X    f = CTP_SHORT( p2 );        /* get function */
X    p2 += 2;            /* advance past function */
X    len -= 2;            /* account for function length */
X    switch( f ) {
X    case CTP_REP:            /* reply */
X        printf(" REPLY data: ");
X        goto break_for;
X        break;
X
X    case CTP_FWD:            /* forward */
X        if( len < 6 ) {
X        printf("Too little data for FORWARD packet");
X        terpri();
X        return;
X        }
X        printf(" FORWARD to: ");
X        petaddr( p2 );        /* print ether addr */
X        terpri();
X        p2 += 6;            /* advance data */
X        len -=6;            /* account for len */
X        break;
X
X    default:
X        printf(" fncn %d. data: ", f );
X        goto break_for;
X    }
X    }
X break_for: ;
X    l2 = len;
X    if( l2 > 32 )
X    l2 = 32;
X    pbytes( p2, l2 );
X    if( len > 32 )
X    printf("...");
X    terpri();
X}
X
Xprocess_xns() {
X    register struct xnspacket *x = &packet.p_ether.e_data.d_xns;
X    xnscount++;
X    printf("XNS IDP len %d transport %d type %d",
X       x->xns_len, x->xns_tc, x->xns_pt );
X    terpri();
X    printf("src: ");
X    pxnsaddr( &x->xns_src );
X    terpri();
X
X    printf("dst: ");
X    pxnsaddr( &x->xns_dst );
X    terpri();
X}
X
Xpxnsaddr( xa )
X    register struct xns_addr *xa;
X{
X    pbytes( xa->xnsa_net, 4 );
X    putchar(':');
X    pbytes( xa->xnsa_host, 6 );
X    printf(" port %d", xa->xnsa_port );
X}
X
Xprocess_other( type )
Xint type;
X{
X    register struct protocol *pp;
X    register int i;
X
X    for( i = 0, pp = protocols; pp->pr_type != 0; i++, pp++ )
X    if( type == pp->pr_type ) {
X        printf( "%s", pp->pr_name );
X        terpri();
X        pr_count[ i ]++;
X        pbytes( packet.p_ether.e_data.d_bytes, 32 );
X        printf("...");
X        terpri();
X        return;
X    }
X    else if( type < pp->pr_type )
X        break;
X    pbytes( packet.p_ether.e_data.d_bytes, 32 );
X    printf("...");
X    terpri();
X    othercount++;
X}
X
Xdump_stats() {
X    register struct protocol *pp;
X    int i;
X
X    if( count > 0 )
X    fprintf( stderr, "count: %d\n", count );
X    if( ipcount > 0 )
X    fprintf( stderr, " ipcount: %d\n", ipcount );
X    if( icmpcount > 0 )
X    fprintf( stderr, "  icmpcount: %d\n", icmpcount );
X    if( tcpcount > 0 )
X    fprintf( stderr, "  tcpcount: %d\n", tcpcount );
X    if( udpcount > 0 )
X    fprintf( stderr, "  udpcount: %d\n", udpcount );
X    if( ndcount > 0 )
X    fprintf( stderr, "  ndcount: %d\n", ndcount );
X    if( egpcount > 0 )
X    fprintf( stderr, "  egpcount: %d\n", egpcount );
X    if( ggpcount > 0 )
X    fprintf( stderr, "  ggpcount: %d\n", ggpcount );
X    if( ippupcount > 0 )
X    fprintf( stderr, "  ippupcount: %d\n", ippupcount );
X    if( ipidpcount > 0 )
X    fprintf( stderr, "  ipidpcount: %d\n", ipidpcount );
X    if( ipfragcount > 0 )
X    fprintf( stderr, "  ipfragcount: %d\n", ipfragcount );
X    if( ipothercount > 0 )
X    fprintf( stderr, "  ipothercount: %d\n", ipothercount );
X    if( ipbadvercount > 0 )
X    fprintf( stderr, "  ipbadvercount: %d\n", ipbadvercount );
X    if( arpcount > 0 )
X    fprintf( stderr, " arpcount: %d\n", arpcount );
X    if( rarpcount > 0 )
X    fprintf( stderr, " rarpcount: %d\n", rarpcount );
X    if( ieeecount > 0 )
X    fprintf( stderr, " ieeecount: %d\n", ieeecount );
X    if( pupcount > 0 )
X    fprintf( stderr, " pupcount: %d\n", pupcount );
X    if( xnscount > 0 )
X    fprintf( stderr, " xnscount: %d\n", xnscount );
X    if( ctpcount > 0 )
X    fprintf( stderr, " ctpcount: %d\n", ctpcount );
X
X    for( i = 0, pp = protocols; pp->pr_type != 0; i++, pp++ )
X    if( pr_count[i] > 0 )
X        fprintf( stderr, " %s: %d\n", pp->pr_name, pr_count[i] );
X
X    if( othercount > 0 )
X    fprintf( stderr, " othercount: %d\n", othercount );
X}
X
Xterpri() {
X    register int i = indent;
X    putchar( '\n' );
X    while( i-- > 0 )
X    putchar( ' ' );
X}
END_OF_rlog.c
if test 20469 -ne `wc -c <rlog.c`; then
    echo shar: \"rlog.c\" unpacked with wrong size!
fi
# end of overwriting check
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked both archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0